概述

虚拟机把描述类的数据从 Class 文件加载到内存，并对数据进行校验，转换解析和初始化，最终形成可以被虚拟机直接使用的 Java 类型，这就是虚拟机的类加载机制。

与哪些在编译时需要进行连接工作的语言不同，在 Java 语言里，类型的加载、连接和初始化过程都是在程序运行期间完成的，这种策略虽然会令类加载时稍微增加一些性能开销，但是会为 Java 应用程序提供高度的灵活性，Java 里天生可以动态拓展的语言特性就是依赖运行期动态加载和动态连接这个特点实现的。

类加载的时机

类从被加载到虚拟机内存中开始，到卸载出内存为止，它的整个生命周期包括：加载（Loading）、验证（Verification）、准备(Preparation)、解析(Resolution)、初始化(Initialization)、使用(Using)和卸载(Unloading)7个阶段。其中准备、验证、解析3个部分统称为连接（Linking）。如图所示：

加载、验证、准备、初始化和卸载这5个阶段的顺序是确定的，类的加载过程必须按照这种顺序按部就班地开始，而解析阶段则不一定：它在某些情况下可以在初始化阶段之后再开始，这是为了支持 Java 语言的运行时绑定（也称为动态绑定或晚期绑定）。以下陈述的内容都已 HotSpot 为基准。

类的加载过程

加载

加载：查找并加载类的二进制数据的过程。

过程：

通过一个类的全限定名来获取定义此类的二进制字节流（并没有指明要从一个 Class 文件中获取，可以从其他渠道，譬如：网络、动态生成、数据库等）；
把字节流所代表的静态存储结构转换为方法区的运行时数据结构。
在内存中生成一个此类的java.lang.Class对象，作为方法区中这个类的各种数据的访问入口。

加载阶段和连接阶段（Linking）的部分内容（如一部分字节码文件格式验证动作）是交叉进行的，加载阶段尚未完成，连接阶段可能已经开始，但这些夹在加载阶段之中进行的动作，仍然属于连接阶段的内容，这两个阶段的开始时间仍然保持着固定的先后顺序。

验证

验证：确保被加载的类的正确性。

验证是连接阶段的第一步，这一阶段的目的是为了确保 Class 文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。

验证阶段大致会完成4个阶段的检验动作：

文件格式验证：验证字节流是否符合 Class 文件格式的规范；例如：是否以魔数 0xCAFEBABE 开头、主次版本号是否在当前虚拟机的处理范围之内、常量池中的常量是否有不被支持的类型。
元数据验证：对字节码描述的信息进行语义分析（注意：对比 javac 编译阶段的语义分析），以保证其描述的信息符合 Java 语言规范的要求；例如：这个类是否有父类，除了 java.lang.Object 之外。
字节码验证：通过数据流和控制流分析，确定程序语义是合法的、符合逻辑的。
符号引用验证：确保解析动作能正确执行。

验证阶段是非常重要的，但不是必须的，它对程序运行期没有影响，如果所引用的类经过反复验证，那么可以考虑采用 -Xverifynone 参数来关闭大部分的类验证措施，以缩短虚拟机类加载的时间。

准备

准备：为类变量分配内存并设置类变量初始值的阶段。

这些变量所使用的内存都将在方法区中进行分配。这时候进行内存分配的仅包括类变量（被 static 修饰的变量），而不包括实例变量，实例变量将会在对象实例化时随着对象一起分配在堆中。其次，这里所说的初始值“通常情况”下是数据类型的零值，假设一个类变量的定义为：

1	public static int value = 123;

那变量 value 在准备阶段过后的初始值为 0 而不是 123.因为这时候尚未开始执行任何 Java 方法，而把 value 赋值为 123 的 putstatic 指令是程序被编译后，存放于类构造器 () 方法之中，所以把 value 赋值为 123 的动作将在初始化阶段才会执行。

至于“特殊情况”是指：public static final int value=123，即当类字段的字段属性是 ConstantValue 时，会在准备阶段初始化为指定的值，所以标注为 final 之后，value 的值在准备阶段初始化为 123 而非 0。

解析

解析：把类中对常量池内的符号引用转换为直接引用。

解析动作主要针对类或接口、字段、类方法、接口方法、方法类型、方法句柄和调用点限定符 7 类符号引用进行。

符号引用 ：

符号引用以一组符号来描述所引用的目标，符号可以是任何形式的字面量，只要使用时能无歧义地定位到目标即可。符号引用与虚拟机实现的内存布局无关，引用的目标并不一定已经加载到内存中。
直接引用：

直接引用可以是直接指向目标的指针，相对偏移量或是一个能间接定位到目标的句柄。直接引用时和虚拟机实现的内存布局相关的，同一个符号引用在不同虚拟机实例上翻译出来的直接引用一般不会相同。如果有了直接引用，那引用的目标必定已经在内存中存在。

初始化

初始化：对类静态变量赋予正确的初始值 (注意和连接时的解析过程区分开)。

类初始化阶段是类加载过程中的最后一步，到了初始化阶段，才真正开始执行类中定义的 Java 程序代码（或者说是字节码）。在准备阶段，变量已经赋过一次系统要求的初始值，而在初始化阶段，则根据程序员通过程序制定的主观计划去初始化类变量和其他资源，或者说：初始化阶段是执行类的构造器 < clinit >() 方法的过程。

< clinit >() 的执行过程：

< clinit >()方法是由编译器自动收集类中的所有类变量的赋值动作和静态语句块 static{} 中的语句合并产生的，编译器收集的顺序是由语句在源文件中出现的顺序所决定的，静态语句块只能访问到定义在静态语句块之前的变量，定义在它之后的变量，在前面的静态语句块可以赋值，但是不能访问。如下：
1
2
3
4
5
6
7
8
{
static
{
i=0;
System.out.println(i);//这句编译器会报错：Cannot reference a field before it is defined（非法向前应用）
}
static int i=1;
}
< clinit >() 方法与实例构造器 < init >() 方法不同，它不需要显示地调用父类构造器，虚拟机会保证在子类 < clinit >() 方法执行之前，父类的 < clinit >() 方法方法已经执行完毕。
由于父类的 < clinit >() 方法先执行，也就意味着父类中定义的静态语句块要优先于子类的变量赋值操作。
< clinit >() 方法对于类或者接口来说并不是必需的，如果一个类中没有静态语句块，也没有对变量的赋值操作，那么编译器可以不为这个类生产 < clinit >() 方法。
接口中不能使用静态语句块，但仍然有变量初始化的赋值操作，因此接口与类一样都会生成 < clinit >() 方法。但接口与类不同的是，执行接口的 < clinit >() 方法不需要先执行父接口的 < clinit >() 方法。只有当父接口中定义的变量使用时，父接口才会初始化。另外，接口的实现类在初始化时也一样不会执行接口的 < clinit >() 方法。
虚拟机会保证一个类的 < clinit >() 方法在多线程环境中被正确的加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的 < clinit >() 方法，其他线程都需要阻塞等待，直到活动线程执行 < clinit >() 方法完毕。如果在一个类的 < clinit >() 方法中有耗时很长的操作，就可能造成多个线程阻塞，在实际应用中这种阻塞往往是隐藏的。
虚拟机规范严格规定了有且只有 5 种情况（jdk1.7）必须对类进行“初始化”（而加载、验证、准备自然需要在此之前开始）：

遇到 new, getstatic,putstatic,invokestatic 这 4 条字节码指令时，如果类没有进行过初始化，则需要先触发其初始化。生成这 4 条指令的最常见的 Java 代码场景是：使用 new 关键字实例化对象的时候、读取或设置一个类的静态字段（被 final 修饰、已在编译器把结果放入常量池的静态字段除外）的时候，以及调用一个类的静态方法的时候。
使用 java.lang.reflect 包的方法对类进行反射调用的时候，如果类没有进行过初始化，则需要先触发其初始化。
当初始化一个类的时候，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化。
当虚拟机启动时，用户需要指定一个要执行的主类（包含 main() 方法的那个类），虚拟机会先初始化这个主类。
当使用 jdk1.7 动态语言支持时，如果一个 java.lang.invoke.MethodHandle 实例最后的解析结果REF_getstatic,REF_putstatic,REF_invokeStatic 的方法句柄，并且这个方法句柄所对应的类没有进行初始化，则需要先出触发其初始化。

初始化的目标

实现对声明类静态变量时指定的初始值的初始化；
实现对使用静态代码块设置的初始值的初始化。

初始化的步骤

如果此类没被加载、连接，则先加载、连接此类；
如果此类的直接父类还未被初始化，则先初始化其直接父类；
如果类中有初始化语句，则按照顺序依次执行初始化语句。

初始化的时机

创建类的实例(new关键字)；
java.lang.reflect包中的方法(如：Class.forName(“xxx”))；
对类的静态变量进行访问或赋值；
访问调用类的静态方法；
初始化一个类的子类，父类本身也会被初始化；
作为程序的启动入口，包含main方法(如：SpringBoot入口类)。

共用的例子

public class SSClass
{
    static
    {
        System.out.println("SSClass init!");
    }
}    
public class SuperClass extends SSClass
{
    static
    {
        System.out.println("SuperClass init!");
    }
 
    public static int value = 123;
 
    public SuperClass()
    {
        System.out.println("init SuperClass");
    }
}
public class SubClass extends SuperClass
{
    static
    {
        System.out.println("SubClass init");
    }
 
    static int a;
 
    public SubClass()
    {
        System.out.println("init SubClass");
    }
}

例子 1

public class NotInitialization
{
    public static void main(String[] args)
    {
        System.out.println(SubClass.value);
    }
}

运行结果：

1
2
3

SSClass init!
SuperClass init!
123

对上面特别是初始化理解了的话理解这段代码就很简单咯
对于静态字段，只有直接定义这个字段的类才会被初始化，因此通过其子类来引用父类中定义的静态字段，只会触发父类的初始化而不会触发子类的初始化。

例子 2

public class NotInitialization
{
    public static void main(String[] args)
    {
        SuperClass[] sca = new SuperClass[10];
    }
}

运行结果：无

通过数组定义来引用类，不会触发此类初始化。

例子 3

public class ConstClass
{
    static
    {
        System.out.println("ConstClass init!");
    }
    public static  final String HELLOWORLD = "hello world";
}
public class NotInitialization
{
    public static void main(String[] args)
    {
        System.out.println(ConstClass.HELLOWORLD);
    }
}

运行结果：无

常量在准备阶段会存入调用类的常量池中，本质上并没有直接引用到定义常量的类，因此不会触发定义常量的类的初始化。

例子 4

public class StaticTest
{
    public static void main(String[] args)
    {
        staticFunction();
    }
 
    static StaticTest st = new StaticTest();
 
    static
    {
        System.out.println("1");
    }
 
    {
        System.out.println("2");
    }
 
    StaticTest()
    {
        System.out.println("3");
        System.out.println("a="+a+",b="+b);
    }
 
    public static void staticFunction(){
        System.out.println("4");
    }
 
    int a=110;
    static int b =112;
}

运行结果：

2
3
a=110,b=0
1
4

类的生命周期是：加载->验证->准备->解析->初始化->使用->卸载，只有在准备阶段和初始化阶段才会涉及类变量的初始化和赋值，因此只针对这两个阶段进行分析；

类的准备阶段需要做是为类变量分配内存并设置默认值，因此类变量 st 为 null 、b 为0；（需要注意的是如果类变量是 final，编译时 javac 将会为 value 生成 ConstantValue 属性，在准备阶段虚拟机就会根据 ConstantValue 的设置将变量设置为指定的值，如果这里这么定义：static final int b=112 ,那么在准备阶段 b 的值就是 112，而不再是 0了。）

类的初始化阶段需要做的是执行类构造器（类构造器是编译器收集所有静态语句块和类变量的赋值语句按语句在源码中的顺序合并生成类构造器，对象的构造方法是 < init >()，类的构造方法是 < clinit >() ，可以在堆栈信息中看到），因此先执行第一条静态变量的赋值语句即 st = new StaticTest () ，此时会进行对象的初始化，对象的初始化是先初始化成员变量(方法块)再执行构造方法，等对象的初始化完成后继续执行之前的类构造器的语句，接下来就不详细说了，按照语句在源码中的顺序执行即可。

这里有个有趣的现象就是：
实例初始化竟然出现在静态初始化之前。因此在实例化 st 变量时，实际上是把实例初始化嵌入到了静态初始化流程中，这也是导致 a 有值 b 没值的原因。

类加载器

JVM 设计者把类加载阶段中的“通过一个类的全限定名来获取描述此类的二进制字节流”这个动作放到 Java 虚拟机外部去实现，以便让应用程序自己决定如何去获取所需要的类。实现这个动作的代码模块称为“类加载器”。

类与类加载器

对于任何一个类，都需要由加载它的类加载器和这个类来确立其在 JVM 中的唯一性。也就是说，两个类来源于同一个Class 文件，并且被同一个类加载器加载，这两个类才相等。(如果被不同的类加载器加载，那么它们的 equals() 、instanceof 等判断都通不过)。

双亲委派模型

从虚拟机的角度来说，只存在两种不同的类加载器：一种是启动类加载器（Bootstrap ClassLoader），该类加载器使用C++ 语言实现，属于虚拟机自身的一部分。另外一种就是所有其它的类加载器，这些类加载器是由 Java 语言实现，独立于 JVM 外部，并且全部继承自抽象类 java.lang.ClassLoader。

从 Java 开发人员的角度来看，大部分Java程序一般会使用到以下三种系统提供的类加载器：

启动类加载器（Bootstrap ClassLoader）：负责加载 JAVA_HOME\lib 目录中并且能被虚拟机识别的类库到 JVM 内存中，如果名称不符合的类库即使放在 lib 目录中也不会被加载。该类加载器无法被 Java 程序直接引用。
扩展类加载器（Extension ClassLoader）：该加载器主要是负责加载 JAVA_HOME\lib\，该加载器可以被开发者直接使用。
应用程序类加载器（Application ClassLoader）：该类加载器也称为系统类加载器，它负责加载用户类路径（Classpath）上所指定的类库，开发者可以直接使用该类加载器，如果应用程序中没有自定义过自己的类加载器，一般情况下这个就是程序中默认的类加载器。

我们的应用程序都是由这三类加载器互相配合进行加载的，我们也可以加入自己定义的类加载器。这些类加载器之间的关系如下图所示：

如上图所示的类加载器之间的这种层次关系，就称为类加载器的双亲委派模型。该模型要求除了顶层的启动类加载器外，其余的类加载器都应当有自己的父类加载器。子类加载器和父类加载器不是以继承的关系来实现，而是通过组合关系来复用父加载器的代码。

双亲委派模型的工作过程为：如果一个类加载器收到了类加载的请求，它首先不会自己去尝试加载这个类，而是把这个请求委派给父类加载器去完成，每一个层次的加载器都是如此，因此所有的类加载请求都会传给顶层的启动类加载器，只有当父加载器反馈自己无法完成该加载请求（该加载器的搜索范围中没有找到对应的类）时，子加载器才会尝试自己去加载。

使用这种模型来组织类加载器之间的关系的好处是 Java 类随着它的类加载器一起具备了一种带有优先级的层次关系。例如 java.lang.Object 类，无论哪个类加载器去加载该类，最终都是由启动类加载器进行加载，因此 Object 类在程序的各种类加载器环境中都是同一个类。否则的话，如果不使用该模型的话，如果用户自定义一个 java.lang.Object 类且存放在 classpath 中，那么系统中将会出现多个 Object 类，应用程序也会变得很混乱。如果我们自定义一个 rt.jar 中已有类的同名 Java 类，会发现 JVM 可以正常编译，但该类永远无法被加载运行。

在 rt.jar 包中的 java.lang.ClassLoader 类中，我们可以查看类加载实现过程的代码，具体源码如下：

protected synchronized Class loadClass(String name, boolean resolve)  
        throws ClassNotFoundException {  
    // 首先检查该name指定的class是否有被加载  
    Class c = findLoadedClass(name);  
    if (c == null) {  
        try {  
            if (parent != null) {  
                // 如果parent不为null，则调用parent的loadClass进行加载  
                c = parent.loadClass(name, false);  
            } else {  
                // parent为null，则调用BootstrapClassLoader进行加载  
                c = findBootstrapClass0(name);  
            }  
        } catch (ClassNotFoundException e) {  
            // 如果仍然无法加载成功，则调用自身的findClass进行加载  
            c = findClass(name);  
        }  
    }  
    if (resolve) {  
        resolveClass(c);  
    }  
    return c;  
}

通过上面代码可以看出，双亲委派模型是通过 loadClass() 方法来实现的，根据代码以及代码中的注释可以很清楚地了解整个过程其实非常简单：先检查是否已经被加载过，如果没有则调用父加载器的 loadClass() 方法，如果父加载器为空则默认使用启动类加载器作为父加载器。如果父类加载器加载失败，则先抛出 ClassNotFoundException ，然后再调用自己的 findClass() 方法进行加载。

自定义类加载器

若要实现自定义类加载器，只需要继承 java.lang.ClassLoader 类，并且重写其 findClass() 方法即可。java.lang.ClassLoader 类的基本职责就是根据一个指定的类的名称，找到或者生成其对应的字节代码，然后从这些字节代码中定义出一个 Java 类，即 java.lang.Class 类的一个实例。除此之外，ClassLoader 还负责加载 Java 应用所需的资源。一个类只能用类加载器加载一次！

在 Java 中，任意一个类都需要由加载它的类加载器和这个类本身一同确定其在 Java 虚拟机中的唯一性，即比较两个类是否相等，只有在这两个类是由同一个类加载器加载的前提之下才有意义，否则，即使这两个类来源于同一个 Class 类文件，只要加载它的类加载器不相同，那么这两个类必定不相等(这里的相等包括代表类的 Class 对象的 equals() 方法、isAssignableFrom() 方法、isInstance() 方法和 instanceof 关键字的结果)。

能不能自己写个类叫java.lang.System？

答案：通常不可以，但可以采取另类方法达到这个需求。
解释：为了不让我们写System类，类加载采用委托机制，这样可以保证爸爸们优先，爸爸们能找到的类，儿子就没有机会加载。而System类是Bootstrap加载器加载的，就算自己重写，也总是使用Java系统提供的System，自己写的System类根本没有机会得到加载。

但是，我们可以自己定义一个类加载器来达到这个目的，为了避免双亲委托机制，这个类加载器也必须是特殊的。由于系统自带的三个类加载器都加载特定目录下的类，如果我们自己的类加载器放在一个特殊的目录，那么系统的加载器就无法加载，也就是最终还是由我们自己的加载器加载。